;;;; -*- Mode: Lisp; Syntax: Common-Lisp; Package: CL-USER; Base: 10 -*-
;;; Regex test case testinput4 from PCRE.
;;;
;;; This file is automatically generated from PCRE's test data with
;;; Perl 5.008004 at 2004-05-24 17:48:50 UTC.
;;;
;;; See: http://www.pcre.org/ for PCRE, Perl Compatible Regex.
;;;
;

;;;; testinput4/6: 
;;;
;;;    Matched
;
(test-case
  "pcre-4/6"
  "a.b"
  "acb"
  '(:unicode t :single-line nil)
  (list "acb") )

;;;; testinput4/7: 
;;;
;;;    Matched
;
(test-case
  "pcre-4/7"
  "a.b"
  (backslash "a\\u007Fb")
  '(:unicode t :single-line nil)
  (list (backslash "a\\u007Fb")) )

;;;; testinput4/8: 
;;;
;;;    Matched
;
(test-case
  "pcre-4/8"
  "a.b"
  (backslash "a\\u0100b")
  '(:unicode t :single-line nil)
  (list (backslash "a\\u0100b")) )

;;;; testinput4/9: 
;;;
;;;    Not matched
;
(test-case
  "pcre-4/9"
  "a.b"
  "*** Failers"
  '(:unicode t :single-line nil)
  nil
 )

;;;; testinput4/10: 
;;;
;;;    Not matched
;
(test-case
  "pcre-4/10"
  "a.b"
  (backslash "a\\nb")
  '(:unicode t :single-line nil)
  nil
 )

;;;; testinput4/13: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-4/13"
  "a(.{3})b"
  (backslash "a\\u4000xyb")
  '(:unicode t :single-line nil)
  (list
    (backslash "a\\u4000xyb")
    (backslash "\\u4000xy") ) )

;;;; testinput4/14: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-4/14"
  "a(.{3})b"
  (backslash "a\\u4000\\u007Fyb")
  '(:unicode t :single-line nil)
  (list
    (backslash "a\\u4000\\u007Fyb")
    (backslash "\\u4000\\u007Fy") ) )

;;;; testinput4/15: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-4/15"
  "a(.{3})b"
  (backslash "a\\u4000\\u0100yb")
  '(:unicode t :single-line nil)
  (list
    (backslash "a\\u4000\\u0100yb")
    (backslash "\\u4000\\u0100y") ) )

;;;; testinput4/16: 
;;;
;;;    Not matched
;
(test-case
  "pcre-4/16"
  "a(.{3})b"
  "*** Failers"
  '(:unicode t :single-line nil)
  nil
 )

;;;; testinput4/17: 
;;;
;;;    Not matched
;
(test-case
  "pcre-4/17"
  "a(.{3})b"
  (backslash "a\\u4000b")
  '(:unicode t :single-line nil)
  nil
 )

;;;; testinput4/18: 
;;;
;;;    Not matched
;
(test-case
  "pcre-4/18"
  "a(.{3})b"
  (backslash "ac\\ncb")
  '(:unicode t :single-line nil)
  nil
 )

;;;; testinput4/21: 
;;;
;;;    Matched with 2 captures.
;
(test-case
  "pcre-4/21"
  "a(.*?)(.)"
  (backslash "a\\u00C0\\u0088b")
  '(:single-line nil)
  (list
    (backslash "a\\u00C0")
    ""
    (backslash "\\u00C0") ) )

;;;; testinput4/24: 
;;;
;;;    Matched with 2 captures.
;
(test-case
  "pcre-4/24"
  "a(.*?)(.)"
  (backslash "a\\u0100b")
  '(:unicode t :single-line nil)
  (list
    (backslash "a\\u0100")
    ""
    (backslash "\\u0100") ) )

;;;; testinput4/27: 
;;;
;;;    Matched with 2 captures.
;
(test-case
  "pcre-4/27"
  "a(.*)(.)"
  (backslash "a\\u00C0\\u0088b")
  '(:single-line nil)
  (list
    (backslash "a\\u00C0\\u0088b")
    (backslash "\\u00C0\\u0088")
    "b" ) )

;;;; testinput4/30: 
;;;
;;;    Matched with 2 captures.
;
(test-case
  "pcre-4/30"
  "a(.*)(.)"
  (backslash "a\\u0100b")
  '(:unicode t :single-line nil)
  (list
    (backslash "a\\u0100b")
    (backslash "\\u0100")
    "b" ) )

;;;; testinput4/33: 
;;;
;;;    Matched with 2 captures.
;
(test-case
  "pcre-4/33"
  "a(.)(.)"
  (backslash "a\\u00C0\\u0092bcd")
  '(:single-line nil)
  (list
    (backslash "a\\u00C0\\u0092")
    (backslash "\\u00C0")
    (backslash "\\u0092") ) )

;;;; testinput4/36: 
;;;
;;;    Matched with 2 captures.
;
(test-case
  "pcre-4/36"
  "a(.)(.)"
  (backslash "a\\u0240bcd")
  '(:unicode t :single-line nil)
  (list
    (backslash "a\\u0240b")
    (backslash "\\u0240")
    "b" ) )

;;;; testinput4/39: 
;;;
;;;    Matched with 2 captures.
;
(test-case
  "pcre-4/39"
  "a(.?)(.)"
  (backslash "a\\u00C0\\u0092bcd")
  '(:single-line nil)
  (list
    (backslash "a\\u00C0\\u0092")
    (backslash "\\u00C0")
    (backslash "\\u0092") ) )

;;;; testinput4/42: 
;;;
;;;    Matched with 2 captures.
;
(test-case
  "pcre-4/42"
  "a(.?)(.)"
  (backslash "a\\u0240bcd")
  '(:unicode t :single-line nil)
  (list
    (backslash "a\\u0240b")
    (backslash "\\u0240")
    "b" ) )

;;;; testinput4/45: 
;;;
;;;    Matched with 2 captures.
;
(test-case
  "pcre-4/45"
  "a(.??)(.)"
  (backslash "a\\u00C0\\u0092bcd")
  '(:single-line nil)
  (list
    (backslash "a\\u00C0")
    ""
    (backslash "\\u00C0") ) )

;;;; testinput4/48: 
;;;
;;;    Matched with 2 captures.
;
(test-case
  "pcre-4/48"
  "a(.??)(.)"
  (backslash "a\\u0240bcd")
  '(:unicode t :single-line nil)
  (list
    (backslash "a\\u0240")
    ""
    (backslash "\\u0240") ) )

;;;; testinput4/51: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-4/51"
  "a(.{3})b"
  (backslash "a\\u1234xyb")
  '(:unicode t :single-line nil)
  (list
    (backslash "a\\u1234xyb")
    (backslash "\\u1234xy") ) )

;;;; testinput4/52: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-4/52"
  "a(.{3})b"
  (backslash "a\\u1234\\u4321yb")
  '(:unicode t :single-line nil)
  (list
    (backslash "a\\u1234\\u4321yb")
    (backslash "\\u1234\\u4321y") ) )

;;;; testinput4/53: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-4/53"
  "a(.{3})b"
  (backslash "a\\u1234\\u4321\\u3412b")
  '(:unicode t :single-line nil)
  (list
    (backslash "a\\u1234\\u4321\\u3412b")
    (backslash "\\u1234\\u4321\\u3412") ) )

;;;; testinput4/54: 
;;;
;;;    Not matched
;
(test-case
  "pcre-4/54"
  "a(.{3})b"
  "*** Failers"
  '(:unicode t :single-line nil)
  nil
 )

;;;; testinput4/55: 
;;;
;;;    Not matched
;
(test-case
  "pcre-4/55"
  "a(.{3})b"
  (backslash "a\\u1234b")
  '(:unicode t :single-line nil)
  nil
 )

;;;; testinput4/56: 
;;;
;;;    Not matched
;
(test-case
  "pcre-4/56"
  "a(.{3})b"
  (backslash "ac\\ncb")
  '(:unicode t :single-line nil)
  nil
 )

;;;; testinput4/59: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-4/59"
  "a(.{3,})b"
  (backslash "a\\u1234xyb")
  '(:unicode t :single-line nil)
  (list
    (backslash "a\\u1234xyb")
    (backslash "\\u1234xy") ) )

;;;; testinput4/60: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-4/60"
  "a(.{3,})b"
  (backslash "a\\u1234\\u4321yb")
  '(:unicode t :single-line nil)
  (list
    (backslash "a\\u1234\\u4321yb")
    (backslash "\\u1234\\u4321y") ) )

;;;; testinput4/61: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-4/61"
  "a(.{3,})b"
  (backslash "a\\u1234\\u4321\\u3412b")
  '(:unicode t :single-line nil)
  (list
    (backslash "a\\u1234\\u4321\\u3412b")
    (backslash "\\u1234\\u4321\\u3412") ) )

;;;; testinput4/62: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-4/62"
  "a(.{3,})b"
  "axxxxbcdefghijb"
  '(:unicode t :single-line nil)
  (list
    "axxxxbcdefghijb"
    "xxxxbcdefghij" ) )

;;;; testinput4/63: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-4/63"
  "a(.{3,})b"
  (backslash "a\\u1234\\u4321\\u3412\\u3421b")
  '(:unicode t :single-line nil)
  (list
    (backslash "a\\u1234\\u4321\\u3412\\u3421b")
    (backslash "\\u1234\\u4321\\u3412\\u3421") ) )

;;;; testinput4/64: 
;;;
;;;    Not matched
;
(test-case
  "pcre-4/64"
  "a(.{3,})b"
  "*** Failers"
  '(:unicode t :single-line nil)
  nil
 )

;;;; testinput4/65: 
;;;
;;;    Not matched
;
(test-case
  "pcre-4/65"
  "a(.{3,})b"
  (backslash "a\\u1234b")
  '(:unicode t :single-line nil)
  nil
 )

;;;; testinput4/68: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-4/68"
  "a(.{3,}?)b"
  (backslash "a\\u1234xyb")
  '(:unicode t :single-line nil)
  (list
    (backslash "a\\u1234xyb")
    (backslash "\\u1234xy") ) )

;;;; testinput4/69: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-4/69"
  "a(.{3,}?)b"
  (backslash "a\\u1234\\u4321yb")
  '(:unicode t :single-line nil)
  (list
    (backslash "a\\u1234\\u4321yb")
    (backslash "\\u1234\\u4321y") ) )

;;;; testinput4/70: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-4/70"
  "a(.{3,}?)b"
  (backslash "a\\u1234\\u4321\\u3412b")
  '(:unicode t :single-line nil)
  (list
    (backslash "a\\u1234\\u4321\\u3412b")
    (backslash "\\u1234\\u4321\\u3412") ) )

;;;; testinput4/71: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-4/71"
  "a(.{3,}?)b"
  "axxxxbcdefghijb"
  '(:unicode t :single-line nil)
  (list
    "axxxxb"
    "xxxx" ) )

;;;; testinput4/72: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-4/72"
  "a(.{3,}?)b"
  (backslash "a\\u1234\\u4321\\u3412\\u3421b")
  '(:unicode t :single-line nil)
  (list
    (backslash "a\\u1234\\u4321\\u3412\\u3421b")
    (backslash "\\u1234\\u4321\\u3412\\u3421") ) )

;;;; testinput4/73: 
;;;
;;;    Not matched
;
(test-case
  "pcre-4/73"
  "a(.{3,}?)b"
  "*** Failers"
  '(:unicode t :single-line nil)
  nil
 )

;;;; testinput4/74: 
;;;
;;;    Not matched
;
(test-case
  "pcre-4/74"
  "a(.{3,}?)b"
  (backslash "a\\u1234b")
  '(:unicode t :single-line nil)
  nil
 )

;;;; testinput4/77: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-4/77"
  "a(.{3,5})b"
  (backslash "a\\u1234xyb")
  '(:unicode t :single-line nil)
  (list
    (backslash "a\\u1234xyb")
    (backslash "\\u1234xy") ) )

;;;; testinput4/78: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-4/78"
  "a(.{3,5})b"
  (backslash "a\\u1234\\u4321yb")
  '(:unicode t :single-line nil)
  (list
    (backslash "a\\u1234\\u4321yb")
    (backslash "\\u1234\\u4321y") ) )

;;;; testinput4/79: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-4/79"
  "a(.{3,5})b"
  (backslash "a\\u1234\\u4321\\u3412b")
  '(:unicode t :single-line nil)
  (list
    (backslash "a\\u1234\\u4321\\u3412b")
    (backslash "\\u1234\\u4321\\u3412") ) )

;;;; testinput4/80: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-4/80"
  "a(.{3,5})b"
  "axxxxbcdefghijb"
  '(:unicode t :single-line nil)
  (list
    "axxxxb"
    "xxxx" ) )

;;;; testinput4/81: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-4/81"
  "a(.{3,5})b"
  (backslash "a\\u1234\\u4321\\u3412\\u3421b")
  '(:unicode t :single-line nil)
  (list
    (backslash "a\\u1234\\u4321\\u3412\\u3421b")
    (backslash "\\u1234\\u4321\\u3412\\u3421") ) )

;;;; testinput4/82: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-4/82"
  "a(.{3,5})b"
  "axbxxbcdefghijb"
  '(:unicode t :single-line nil)
  (list
    "axbxxb"
    "xbxx" ) )

;;;; testinput4/83: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-4/83"
  "a(.{3,5})b"
  "axxxxxbcdefghijb"
  '(:unicode t :single-line nil)
  (list
    "axxxxxb"
    "xxxxx" ) )

;;;; testinput4/84: 
;;;
;;;    Not matched
;
(test-case
  "pcre-4/84"
  "a(.{3,5})b"
  "*** Failers"
  '(:unicode t :single-line nil)
  nil
 )

;;;; testinput4/85: 
;;;
;;;    Not matched
;
(test-case
  "pcre-4/85"
  "a(.{3,5})b"
  (backslash "a\\u1234b")
  '(:unicode t :single-line nil)
  nil
 )

;;;; testinput4/86: 
;;;
;;;    Not matched
;
(test-case
  "pcre-4/86"
  "a(.{3,5})b"
  "axxxxxxbcdefghijb"
  '(:unicode t :single-line nil)
  nil
 )

;;;; testinput4/89: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-4/89"
  "a(.{3,5}?)b"
  (backslash "a\\u1234xyb")
  '(:unicode t :single-line nil)
  (list
    (backslash "a\\u1234xyb")
    (backslash "\\u1234xy") ) )

;;;; testinput4/90: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-4/90"
  "a(.{3,5}?)b"
  (backslash "a\\u1234\\u4321yb")
  '(:unicode t :single-line nil)
  (list
    (backslash "a\\u1234\\u4321yb")
    (backslash "\\u1234\\u4321y") ) )

;;;; testinput4/91: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-4/91"
  "a(.{3,5}?)b"
  (backslash "a\\u1234\\u4321\\u3412b")
  '(:unicode t :single-line nil)
  (list
    (backslash "a\\u1234\\u4321\\u3412b")
    (backslash "\\u1234\\u4321\\u3412") ) )

;;;; testinput4/92: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-4/92"
  "a(.{3,5}?)b"
  "axxxxbcdefghijb"
  '(:unicode t :single-line nil)
  (list
    "axxxxb"
    "xxxx" ) )

;;;; testinput4/93: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-4/93"
  "a(.{3,5}?)b"
  (backslash "a\\u1234\\u4321\\u3412\\u3421b")
  '(:unicode t :single-line nil)
  (list
    (backslash "a\\u1234\\u4321\\u3412\\u3421b")
    (backslash "\\u1234\\u4321\\u3412\\u3421") ) )

;;;; testinput4/94: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-4/94"
  "a(.{3,5}?)b"
  "axbxxbcdefghijb"
  '(:unicode t :single-line nil)
  (list
    "axbxxb"
    "xbxx" ) )

;;;; testinput4/95: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-4/95"
  "a(.{3,5}?)b"
  "axxxxxbcdefghijb"
  '(:unicode t :single-line nil)
  (list
    "axxxxxb"
    "xxxxx" ) )

;;;; testinput4/96: 
;;;
;;;    Not matched
;
(test-case
  "pcre-4/96"
  "a(.{3,5}?)b"
  "*** Failers"
  '(:unicode t :single-line nil)
  nil
 )

;;;; testinput4/97: 
;;;
;;;    Not matched
;
(test-case
  "pcre-4/97"
  "a(.{3,5}?)b"
  (backslash "a\\u1234b")
  '(:unicode t :single-line nil)
  nil
 )

;;;; testinput4/98: 
;;;
;;;    Not matched
;
(test-case
  "pcre-4/98"
  "a(.{3,5}?)b"
  "axxxxxxbcdefghijb"
  '(:unicode t :single-line nil)
  nil
 )

;;;; testinput4/101: 
;;;
;;;    Not matched
;
(test-case
  "pcre-4/101"
  "^[a\\x{c0}]"
  "*** Failers"
  '(:unicode t :single-line nil)
  nil
 )

;;;; testinput4/102: 
;;;
;;;    Not matched
;
(test-case
  "pcre-4/102"
  "^[a\\x{c0}]"
  (backslash "\\u0100")
  '(:unicode t :single-line nil)
  nil
 )

;;;; testinput4/105: 
;;;
;;;    Matched
;
(test-case
  "pcre-4/105"
  "(?<=aXb)cd"
  "aXbcd"
  '(:unicode t :single-line nil)
  (list "cd") )

;;;; testinput4/108: 
;;;
;;;    Matched
;
(test-case
  "pcre-4/108"
  "(?<=a\\x{100}b)cd"
  (backslash "a\\u0100bcd")
  '(:unicode t :single-line nil)
  (list "cd") )

;;;; testinput4/111: 
;;;
;;;    Matched
;
(test-case
  "pcre-4/111"
  "(?<=a\\x{100000}b)cd"
  (backslash "a\\u100000bcd")
  '(:unicode t :single-line nil)
  (list "cd") )

;;;; testinput4/114: 
;;;
;;;    Matched
;
(test-case
  "pcre-4/114"
  "(?:\\x{100}){3}b"
  (backslash "\\u0100\\u0100\\u0100b")
  '(:unicode t :single-line nil)
  (list (backslash "\\u0100\\u0100\\u0100b")) )

;;;; testinput4/115: 
;;;
;;;    Not matched
;
(test-case
  "pcre-4/115"
  "(?:\\x{100}){3}b"
  "*** Failers"
  '(:unicode t :single-line nil)
  nil
 )

;;;; testinput4/116: 
;;;
;;;    Not matched
;
(test-case
  "pcre-4/116"
  "(?:\\x{100}){3}b"
  (backslash "\\u0100\\u0100b")
  '(:unicode t :single-line nil)
  nil
 )

;;;; testinput4/119: 
;;;
;;;    Matched
;
(test-case
  "pcre-4/119"
  "\\x{ab}"
  (backslash "\\u00AB")
  '(:unicode t :single-line nil)
  (list (backslash "\\u00AB")) )

;;;; testinput4/120: 
;;;
;;;    Matched
;
(test-case
  "pcre-4/120"
  "\\x{ab}"
  (backslash "\\u00C2\\u00AB")
  '(:unicode t :single-line nil)
  (list (backslash "\\u00AB")) )

;;;; testinput4/121: 
;;;
;;;    Not matched
;
(test-case
  "pcre-4/121"
  "\\x{ab}"
  "*** Failers"
  '(:unicode t :single-line nil)
  nil
 )

;;;; testinput4/122: 
;;;
;;;    Not matched
;
(test-case
  "pcre-4/122"
  "\\x{ab}"
  (backslash "\\u0000{ab}")
  '(:unicode t :single-line nil)
  nil
 )

;;;; testinput4/125: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-4/125"
  "(?<=(.))X"
  "WXYZ"
  '(:unicode t :single-line nil)
  (list
    "X"
    "W" ) )

;;;; testinput4/126: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-4/126"
  "(?<=(.))X"
  (backslash "\\u0256XYZ")
  '(:unicode t :single-line nil)
  (list
    "X"
    (backslash "\\u0256") ) )

;;;; testinput4/127: 
;;;
;;;    Not matched
;
(test-case
  "pcre-4/127"
  "(?<=(.))X"
  "*** Failers"
  '(:unicode t :single-line nil)
  nil
 )

;;;; testinput4/128: 
;;;
;;;    Not matched
;
(test-case
  "pcre-4/128"
  "(?<=(.))X"
  "XYZ"
  '(:unicode t :single-line nil)
  nil
 )

;;;; testinput4/131: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-4/131"
  "X(\\C{3})"
  (backslash "X\\u1234")
  '(:unicode t :single-line nil)
  (list
    (backslash "X\\u1234")
    (backslash "\\u1234") ) )

;;;; testinput4/134: 
;;;
;;;    Matched with 1 captures.
;
(test-case
  "pcre-4/134"
  "X(\\C{4})"
  (backslash "X\\u1234YZ")
  '(:unicode t :single-line nil)
  (list
    (backslash "X\\u1234Y")
    (backslash "\\u1234Y") ) )

;;;; testinput4/137: 
;;;
;;;    Matched
;
(test-case
  "pcre-4/137"
  "X\\C*"
  "XYZabcdce"
  '(:unicode t :single-line nil)
  (list "XYZabcdce") )

;;;; testinput4/140: 
;;;
;;;    Matched
;
(test-case
  "pcre-4/140"
  "X\\C*?"
  "XYZabcde"
  '(:unicode t :single-line nil)
  (list "X") )

;;;; testinput4/143: 
;;;
;;;    Matched
;
(test-case
  "pcre-4/143"
  "X\\C{3,5}"
  "Xabcdefg"
  '(:unicode t :single-line nil)
  (list "Xabcde") )

;;;; testinput4/144: 
;;;
;;;    Matched
;
(test-case
  "pcre-4/144"
  "X\\C{3,5}"
  (backslash "X\\u1234")
  '(:unicode t :single-line nil)
  (list (backslash "X\\u1234")) )

;;;; testinput4/145: 
;;;
;;;    Matched
;
(test-case
  "pcre-4/145"
  "X\\C{3,5}"
  (backslash "X\\u1234YZ")
  '(:unicode t :single-line nil)
  (list (backslash "X\\u1234YZ")) )

;;;; testinput4/146: 
;;;
;;;    Matched
;
(test-case
  "pcre-4/146"
  "X\\C{3,5}"
  (backslash "X\\u1234\\u0512")
  '(:unicode t :single-line nil)
  (list (backslash "X\\u1234\\u0512")) )

;;;; testinput4/147: 
;;;
;;;    Matched
;
(test-case
  "pcre-4/147"
  "X\\C{3,5}"
  (backslash "X\\u1234\\u0512YZ")
  '(:unicode t :single-line nil)
  (list (backslash "X\\u1234\\u0512")) )

;;;; testinput4/150: 
;;;
;;;    Matched
;
(test-case
  "pcre-4/150"
  "X\\C{3,5}?"
  "Xabcdefg"
  '(:unicode t :single-line nil)
  (list "Xabc") )

;;;; testinput4/151: 
;;;
;;;    Matched
;
(test-case
  "pcre-4/151"
  "X\\C{3,5}?"
  (backslash "X\\u1234")
  '(:unicode t :single-line nil)
  (list (backslash "X\\u1234")) )

;;;; testinput4/152: 
;;;
;;;    Matched
;
(test-case
  "pcre-4/152"
  "X\\C{3,5}?"
  (backslash "X\\u1234YZ")
  '(:unicode t :single-line nil)
  (list (backslash "X\\u1234")) )

;;;; testinput4/153: 
;;;
;;;    Matched
;
(test-case
  "pcre-4/153"
  "X\\C{3,5}?"
  (backslash "X\\u1234\\u0512")
  '(:unicode t :single-line nil)
  (list (backslash "X\\u1234")) )

;;;; testinput4/156: 
;;;
;;;    
;
(test-case/g
  "pcre-4/156"
  "[^a]+"
  "bcd"
  '(:unicode t :single-line nil)
  (list "bcd")
    "" )

;;;; testinput4/157: 
;;;
;;;    
;
(test-case/g
  "pcre-4/157"
  "[^a]+"
  (backslash "\\u0100aY\\u0256Z")
  '(:unicode t :single-line nil)
  (list (backslash "\\u0100")
        (backslash "Y\\u0256Z") )
    "" )

;;;; testinput4/160: 
;;;
;;;    Matched
;
(test-case
  "pcre-4/160"
  "^[^a]{2}"
  (backslash "\\u0100bc")
  '(:unicode t :single-line nil)
  (list (backslash "\\u0100b")) )

;;;; testinput4/163: 
;;;
;;;    Matched
;
(test-case
  "pcre-4/163"
  "^[^a]{2,}"
  (backslash "\\u0100bcAa")
  '(:unicode t :single-line nil)
  (list (backslash "\\u0100bcA")) )

;;;; testinput4/166: 
;;;
;;;    Matched
;
(test-case
  "pcre-4/166"
  "^[^a]{2,}?"
  (backslash "\\u0100bca")
  '(:unicode t :single-line nil)
  (list (backslash "\\u0100b")) )

;;;; testinput4/169: 
;;;
;;;    
;
(test-case/g
  "pcre-4/169"
  "[^a]+"
  "bcd"
  '(:unicode t :ignore-case t :single-line nil)
  (list "bcd")
    "" )

;;;; testinput4/170: 
;;;
;;;    
;
(test-case/g
  "pcre-4/170"
  "[^a]+"
  (backslash "\\u0100aY\\u0256Z")
  '(:unicode t :ignore-case t :single-line nil)
  (list (backslash "\\u0100")
        (backslash "Y\\u0256Z") )
    "" )

;;;; testinput4/173: 
;;;
;;;    Matched
;
(test-case
  "pcre-4/173"
  "^[^a]{2}"
  (backslash "\\u0100bc")
  '(:unicode t :ignore-case t :single-line nil)
  (list (backslash "\\u0100b")) )

;;;; testinput4/176: 
;;;
;;;    Matched
;
(test-case
  "pcre-4/176"
  "^[^a]{2,}"
  (backslash "\\u0100bcAa")
  '(:unicode t :ignore-case t :single-line nil)
  (list (backslash "\\u0100bc")) )

;;;; testinput4/179: 
;;;
;;;    Matched
;
(test-case
  "pcre-4/179"
  "^[^a]{2,}?"
  (backslash "\\u0100bca")
  '(:unicode t :ignore-case t :single-line nil)
  (list (backslash "\\u0100b")) )

;;;; testinput4/182: 
;;;
;;;    Matched
;
(test-case
  "pcre-4/182"
  "\\x{100}{0,0}"
  "abcd"
  '(:unicode t :single-line nil)
  (list "") )

;;;; testinput4/185: 
;;;
;;;    Matched
;
(test-case
  "pcre-4/185"
  "\\x{100}?"
  "abcd"
  '(:unicode t :single-line nil)
  (list "") )

;;;; testinput4/186: 
;;;
;;;    Matched
;
(test-case
  "pcre-4/186"
  "\\x{100}?"
  (backslash "\\u0100\\u0100")
  '(:unicode t :single-line nil)
  (list (backslash "\\u0100")) )

;;;; testinput4/189: 
;;;
;;;    Matched
;
(test-case
  "pcre-4/189"
  "\\x{100}{0,3}"
  (backslash "\\u0100\\u0100")
  '(:unicode t :single-line nil)
  (list (backslash "\\u0100\\u0100")) )

;;;; testinput4/190: 
;;;
;;;    Matched
;
(test-case
  "pcre-4/190"
  "\\x{100}{0,3}"
  (backslash "\\u0100\\u0100\\u0100\\u0100")
  '(:unicode t :single-line nil)
  (list (backslash "\\u0100\\u0100\\u0100")) )

;;;; testinput4/193: 
;;;
;;;    Matched
;
(test-case
  "pcre-4/193"
  "\\x{100}*"
  "abce"
  '(:unicode t :single-line nil)
  (list "") )

;;;; testinput4/194: 
;;;
;;;    Matched
;
(test-case
  "pcre-4/194"
  "\\x{100}*"
  (backslash "\\u0100\\u0100\\u0100\\u0100")
  '(:unicode t :single-line nil)
  (list (backslash "\\u0100\\u0100\\u0100\\u0100")) )

;;;; testinput4/197: 
;;;
;;;    Matched
;
(test-case
  "pcre-4/197"
  "\\x{100}{1,1}"
  (backslash "abcd\\u0100\\u0100\\u0100\\u0100")
  '(:unicode t :single-line nil)
  (list (backslash "\\u0100")) )

;;;; testinput4/200: 
;;;
;;;    Matched
;
(test-case
  "pcre-4/200"
  "\\x{100}{1,3}"
  (backslash "abcd\\u0100\\u0100\\u0100\\u0100")
  '(:unicode t :single-line nil)
  (list (backslash "\\u0100\\u0100\\u0100")) )

;;;; testinput4/203: 
;;;
;;;    Matched
;
(test-case
  "pcre-4/203"
  "\\x{100}+"
  (backslash "abcd\\u0100\\u0100\\u0100\\u0100")
  '(:unicode t :single-line nil)
  (list (backslash "\\u0100\\u0100\\u0100\\u0100")) )

;;;; testinput4/206: 
;;;
;;;    Matched
;
(test-case
  "pcre-4/206"
  "\\x{100}{3}"
  (backslash "abcd\\u0100\\u0100\\u0100XX")
  '(:unicode t :single-line nil)
  (list (backslash "\\u0100\\u0100\\u0100")) )

;;;; testinput4/209: 
;;;
;;;    Matched
;
(test-case
  "pcre-4/209"
  "\\x{100}{3,5}"
  (backslash "abcd\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100XX")
  '(:unicode t :single-line nil)
  (list (backslash "\\u0100\\u0100\\u0100\\u0100\\u0100")) )

;;;; testinput4/212: 
;;;
;;;    Matched
;
(test-case
  "pcre-4/212"
  "\\x{100}{3,}"
  (backslash "abcd\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100XX")
  '(:unicode t :single-line nil)
  (list (backslash "\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100")) )

;;;; testinput4/215: 
;;;
;;;    Matched
;
(test-case
  "pcre-4/215"
  "(?<=a\\x{100}{2}b)X"
  (backslash "Xyyya\\u0100\\u0100bXzzz")
  '(:unicode t :single-line nil)
  (list "X") )

;;;; testinput4/218: 
;;;
;;;    Matched
;
(test-case
  "pcre-4/218"
  "\\D*"
  "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
  '(:unicode t :single-line nil)
  (list "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa") )

;;;; testinput4/221: 
;;;
;;;    Matched
;
(test-case
  "pcre-4/221"
  "\\D*"
  (backslash "\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100")
  '(:unicode t :single-line nil)
  (list (backslash "\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100\\u0100")) )

;;;; testinput4/224: 
;;;
;;;    Matched
;
(test-case
  "pcre-4/224"
  "\\D"
  "1X2"
  '(:unicode t :single-line nil)
  (list "X") )

;;;; testinput4/225: 
;;;
;;;    Matched
;
(test-case
  "pcre-4/225"
  "\\D"
  (backslash "1\\u01002")
  '(:unicode t :single-line nil)
  (list (backslash "\\u0100")) )

;;;; testinput4/228: 
;;;
;;;    Matched
;
(test-case
  "pcre-4/228"
  ">\\S"
  "> >X Y"
  '(:unicode t :single-line nil)
  (list ">X") )

;;;; testinput4/229: 
;;;
;;;    Matched
;
(test-case
  "pcre-4/229"
  ">\\S"
  (backslash "> >\\u0100 Y")
  '(:unicode t :single-line nil)
  (list (backslash ">\\u0100")) )

;;;; testinput4/232: 
;;;
;;;    Matched
;
(test-case
  "pcre-4/232"
  "\\W"
  "A.B"
  '(:unicode t :single-line nil)
  (list ".") )

;;;; testinput4/233: 
;;;
;;;    Not matched
;
(test-case
  "pcre-4/233"
  "\\W"
  (backslash "A\\u0100B")
  '(:unicode t :single-line nil)
  nil
 )

;;;; testinput4/236: 
;;;
;;;    Matched
;
(test-case
  "pcre-4/236"
  "\\d"
  (backslash "\\u01003")
  '(:unicode t :single-line nil)
  (list "3") )

;;;; testinput4/239: 
;;;
;;;    Matched
;
(test-case
  "pcre-4/239"
  "\\s"
  (backslash "\\u0100 X")
  '(:unicode t :single-line nil)
  (list " ") )

;;;; testinput4/242: 
;;;
;;;    Matched
;
(test-case
  "pcre-4/242"
  "\\w"
  (backslash "\\u0100X")
  '(:unicode t :single-line nil)
  (list (backslash "\\u0100")) )

;;;; testinput4/245: 
;;;
;;;    Matched
;
(test-case
  "pcre-4/245"
  "\\D+"
  "12abcd34"
  '(:unicode t :single-line nil)
  (list "abcd") )

;;;; testinput4/246: 
;;;
;;;    Matched
;
(test-case
  "pcre-4/246"
  "\\D+"
  "*** Failers"
  '(:unicode t :single-line nil)
  (list "*** Failers") )

;;;; testinput4/247: 
;;;
;;;    Not matched
;
(test-case
  "pcre-4/247"
  "\\D+"
  "1234"
  '(:unicode t :single-line nil)
  nil
 )

;;;; testinput4/250: 
;;;
;;;    Matched
;
(test-case
  "pcre-4/250"
  "\\D{2,3}"
  "12abcd34"
  '(:unicode t :single-line nil)
  (list "abc") )

;;;; testinput4/251: 
;;;
;;;    Matched
;
(test-case
  "pcre-4/251"
  "\\D{2,3}"
  "12ab34"
  '(:unicode t :single-line nil)
  (list "ab") )

;;;; testinput4/252: 
;;;
;;;    Matched
;
(test-case
  "pcre-4/252"
  "\\D{2,3}"
  "*** Failers"
  '(:unicode t :single-line nil)
  (list "***") )

;;;; testinput4/253: 
;;;
;;;    Not matched
;
(test-case
  "pcre-4/253"
  "\\D{2,3}"
  "1234"
  '(:unicode t :single-line nil)
  nil
 )

;;;; testinput4/254: 
;;;
;;;    Not matched
;
(test-case
  "pcre-4/254"
  "\\D{2,3}"
  "12a34"
  '(:unicode t :single-line nil)
  nil
 )

;;;; testinput4/257: 
;;;
;;;    Matched
;
(test-case
  "pcre-4/257"
  "\\D{2,3}?"
  "12abcd34"
  '(:unicode t :single-line nil)
  (list "ab") )

;;;; testinput4/258: 
;;;
;;;    Matched
;
(test-case
  "pcre-4/258"
  "\\D{2,3}?"
  "12ab34"
  '(:unicode t :single-line nil)
  (list "ab") )

;;;; testinput4/259: 
;;;
;;;    Matched
;
(test-case
  "pcre-4/259"
  "\\D{2,3}?"
  "*** Failers"
  '(:unicode t :single-line nil)
  (list "**") )

;;;; testinput4/260: 
;;;
;;;    Not matched
;
(test-case
  "pcre-4/260"
  "\\D{2,3}?"
  "1234"
  '(:unicode t :single-line nil)
  nil
 )

;;;; testinput4/261: 
;;;
;;;    Not matched
;
(test-case
  "pcre-4/261"
  "\\D{2,3}?"
  "12a34"
  '(:unicode t :single-line nil)
  nil
 )

;;;; testinput4/264: 
;;;
;;;    Matched
;
(test-case
  "pcre-4/264"
  "\\d+"
  "12abcd34"
  '(:unicode t :single-line nil)
  (list "12") )

;;;; testinput4/265: 
;;;
;;;    Not matched
;
(test-case
  "pcre-4/265"
  "\\d+"
  "*** Failers"
  '(:unicode t :single-line nil)
  nil
 )

;;;; testinput4/268: 
;;;
;;;    Matched
;
(test-case
  "pcre-4/268"
  "\\d{2,3}"
  "12abcd34"
  '(:unicode t :single-line nil)
  (list "12") )

;;;; testinput4/269: 
;;;
;;;    Matched
;
(test-case
  "pcre-4/269"
  "\\d{2,3}"
  "1234abcd"
  '(:unicode t :single-line nil)
  (list "123") )

;;;; testinput4/270: 
;;;
;;;    Not matched
;
(test-case
  "pcre-4/270"
  "\\d{2,3}"
  "*** Failers"
  '(:unicode t :single-line nil)
  nil
 )

;;;; testinput4/271: 
;;;
;;;    Not matched
;
(test-case
  "pcre-4/271"
  "\\d{2,3}"
  "1.4"
  '(:unicode t :single-line nil)
  nil
 )

;;;; testinput4/274: 
;;;
;;;    Matched
;
(test-case
  "pcre-4/274"
  "\\d{2,3}?"
  "12abcd34"
  '(:unicode t :single-line nil)
  (list "12") )

;;;; testinput4/275: 
;;;
;;;    Matched
;
(test-case
  "pcre-4/275"
  "\\d{2,3}?"
  "1234abcd"
  '(:unicode t :single-line nil)
  (list "12") )

;;;; testinput4/276: 
;;;
;;;    Not matched
;
(test-case
  "pcre-4/276"
  "\\d{2,3}?"
  "*** Failers"
  '(:unicode t :single-line nil)
  nil
 )

;;;; testinput4/277: 
;;;
;;;    Not matched
;
(test-case
  "pcre-4/277"
  "\\d{2,3}?"
  "1.4"
  '(:unicode t :single-line nil)
  nil
 )

;;;; testinput4/280: 
;;;
;;;    Matched
;
(test-case
  "pcre-4/280"
  "\\S+"
  "12abcd34"
  '(:unicode t :single-line nil)
  (list "12abcd34") )

;;;; testinput4/281: 
;;;
;;;    Matched
;
(test-case
  "pcre-4/281"
  "\\S+"
  "*** Failers"
  '(:unicode t :single-line nil)
  (list "***") )

;;;; testinput4/282: 
;;;
;;;    Not matched
;
(test-case
  "pcre-4/282"
  "\\S+"
  ""
  '(:unicode t :single-line nil)
  nil
 )

;;;; testinput4/285: 
;;;
;;;    Matched
;
(test-case
  "pcre-4/285"
  "\\S{2,3}"
  "12abcd34"
  '(:unicode t :single-line nil)
  (list "12a") )

;;;; testinput4/286: 
;;;
;;;    Matched
;
(test-case
  "pcre-4/286"
  "\\S{2,3}"
  "1234abcd"
  '(:unicode t :single-line nil)
  (list "123") )

;;;; testinput4/287: 
;;;
;;;    Matched
;
(test-case
  "pcre-4/287"
  "\\S{2,3}"
  "*** Failers"
  '(:unicode t :single-line nil)
  (list "***") )

;;;; testinput4/288: 
;;;
;;;    Not matched
;
(test-case
  "pcre-4/288"
  "\\S{2,3}"
  ""
  '(:unicode t :single-line nil)
  nil
 )

;;;; testinput4/291: 
;;;
;;;    Matched
;
(test-case
  "pcre-4/291"
  "\\S{2,3}?"
  "12abcd34"
  '(:unicode t :single-line nil)
  (list "12") )

;;;; testinput4/292: 
;;;
;;;    Matched
;
(test-case
  "pcre-4/292"
  "\\S{2,3}?"
  "1234abcd"
  '(:unicode t :single-line nil)
  (list "12") )

;;;; testinput4/293: 
;;;
;;;    Matched
;
(test-case
  "pcre-4/293"
  "\\S{2,3}?"
  "*** Failers"
  '(:unicode t :single-line nil)
  (list "**") )

;;;; testinput4/294: 
;;;
;;;    Not matched
;
(test-case
  "pcre-4/294"
  "\\S{2,3}?"
  ""
  '(:unicode t :single-line nil)
  nil
 )

;;;; testinput4/297: 
;;;
;;;    Matched
;
(test-case
  "pcre-4/297"
  ">\\s+<"
  "12>      <34"
  '(:unicode t :single-line nil)
  (list ">      <") )

;;;; testinput4/298: 
;;;
;;;    Not matched
;
(test-case
  "pcre-4/298"
  ">\\s+<"
  "*** Failers"
  '(:unicode t :single-line nil)
  nil
 )

;;;; testinput4/301: 
;;;
;;;    Matched
;
(test-case
  "pcre-4/301"
  ">\\s{2,3}<"
  "ab>  <cd"
  '(:unicode t :single-line nil)
  (list ">  <") )

;;;; testinput4/302: 
;;;
;;;    Matched
;
(test-case
  "pcre-4/302"
  ">\\s{2,3}<"
  "ab>   <ce"
  '(:unicode t :single-line nil)
  (list ">   <") )

;;;; testinput4/303: 
;;;
;;;    Not matched
;
(test-case
  "pcre-4/303"
  ">\\s{2,3}<"
  "*** Failers"
  '(:unicode t :single-line nil)
  nil
 )

;;;; testinput4/304: 
;;;
;;;    Not matched
;
(test-case
  "pcre-4/304"
  ">\\s{2,3}<"
  "ab>    <cd"
  '(:unicode t :single-line nil)
  nil
 )

;;;; testinput4/307: 
;;;
;;;    Matched
;
(test-case
  "pcre-4/307"
  ">\\s{2,3}?<"
  "ab>  <cd"
  '(:unicode t :single-line nil)
  (list ">  <") )

;;;; testinput4/308: 
;;;
;;;    Matched
;
(test-case
  "pcre-4/308"
  ">\\s{2,3}?<"
  "ab>   <ce"
  '(:unicode t :single-line nil)
  (list ">   <") )

;;;; testinput4/309: 
;;;
;;;    Not matched
;
(test-case
  "pcre-4/309"
  ">\\s{2,3}?<"
  "*** Failers"
  '(:unicode t :single-line nil)
  nil
 )

;;;; testinput4/310: 
;;;
;;;    Not matched
;
(test-case
  "pcre-4/310"
  ">\\s{2,3}?<"
  "ab>    <cd"
  '(:unicode t :single-line nil)
  nil
 )

;;;; testinput4/313: 
;;;
;;;    Matched
;
(test-case
  "pcre-4/313"
  "\\w+"
  "12      34"
  '(:unicode t :single-line nil)
  (list "12") )

;;;; testinput4/314: 
;;;
;;;    Matched
;
(test-case
  "pcre-4/314"
  "\\w+"
  "*** Failers"
  '(:unicode t :single-line nil)
  (list "Failers") )

;;;; testinput4/315: 
;;;
;;;    Not matched
;
(test-case
  "pcre-4/315"
  "\\w+"
  "+++=*!"
  '(:unicode t :single-line nil)
  nil
 )

;;;; testinput4/318: 
;;;
;;;    Matched
;
(test-case
  "pcre-4/318"
  "\\w{2,3}"
  "ab  cd"
  '(:unicode t :single-line nil)
  (list "ab") )

;;;; testinput4/319: 
;;;
;;;    Matched
;
(test-case
  "pcre-4/319"
  "\\w{2,3}"
  "abcd ce"
  '(:unicode t :single-line nil)
  (list "abc") )

;;;; testinput4/320: 
;;;
;;;    Matched
;
(test-case
  "pcre-4/320"
  "\\w{2,3}"
  "*** Failers"
  '(:unicode t :single-line nil)
  (list "Fai") )

;;;; testinput4/321: 
;;;
;;;    Not matched
;
(test-case
  "pcre-4/321"
  "\\w{2,3}"
  "a.b.c"
  '(:unicode t :single-line nil)
  nil
 )

;;;; testinput4/324: 
;;;
;;;    Matched
;
(test-case
  "pcre-4/324"
  "\\w{2,3}?"
  "ab  cd"
  '(:unicode t :single-line nil)
  (list "ab") )

;;;; testinput4/325: 
;;;
;;;    Matched
;
(test-case
  "pcre-4/325"
  "\\w{2,3}?"
  "abcd ce"
  '(:unicode t :single-line nil)
  (list "ab") )

;;;; testinput4/326: 
;;;
;;;    Matched
;
(test-case
  "pcre-4/326"
  "\\w{2,3}?"
  "*** Failers"
  '(:unicode t :single-line nil)
  (list "Fa") )

;;;; testinput4/327: 
;;;
;;;    Not matched
;
(test-case
  "pcre-4/327"
  "\\w{2,3}?"
  "a.b.c"
  '(:unicode t :single-line nil)
  nil
 )

;;;; testinput4/330: 
;;;
;;;    Matched
;
(test-case
  "pcre-4/330"
  "\\W+"
  "12====34"
  '(:unicode t :single-line nil)
  (list "====") )

;;;; testinput4/331: 
;;;
;;;    Matched
;
(test-case
  "pcre-4/331"
  "\\W+"
  "*** Failers"
  '(:unicode t :single-line nil)
  (list "*** ") )

;;;; testinput4/332: 
;;;
;;;    Not matched
;
(test-case
  "pcre-4/332"
  "\\W+"
  "abcd"
  '(:unicode t :single-line nil)
  nil
 )

;;;; testinput4/335: 
;;;
;;;    Matched
;
(test-case
  "pcre-4/335"
  "\\W{2,3}"
  "ab====cd"
  '(:unicode t :single-line nil)
  (list "===") )

;;;; testinput4/336: 
;;;
;;;    Matched
;
(test-case
  "pcre-4/336"
  "\\W{2,3}"
  "ab==cd"
  '(:unicode t :single-line nil)
  (list "==") )

;;;; testinput4/337: 
;;;
;;;    Matched
;
(test-case
  "pcre-4/337"
  "\\W{2,3}"
  "*** Failers"
  '(:unicode t :single-line nil)
  (list "***") )

;;;; testinput4/338: 
;;;
;;;    Not matched
;
(test-case
  "pcre-4/338"
  "\\W{2,3}"
  "a.b.c"
  '(:unicode t :single-line nil)
  nil
 )

;;;; testinput4/341: 
;;;
;;;    Matched
;
(test-case
  "pcre-4/341"
  "\\W{2,3}?"
  "ab====cd"
  '(:unicode t :single-line nil)
  (list "==") )

;;;; testinput4/342: 
;;;
;;;    Matched
;
(test-case
  "pcre-4/342"
  "\\W{2,3}?"
  "ab==cd"
  '(:unicode t :single-line nil)
  (list "==") )

;;;; testinput4/343: 
;;;
;;;    Matched
;
(test-case
  "pcre-4/343"
  "\\W{2,3}?"
  "*** Failers"
  '(:unicode t :single-line nil)
  (list "**") )

;;;; testinput4/344: 
;;;
;;;    Not matched
;
(test-case
  "pcre-4/344"
  "\\W{2,3}?"
  "a.b.c"
  '(:unicode t :single-line nil)
  nil
 )

;;;; testinput4/347: 
;;;
;;;    Matched
;
(test-case
  "pcre-4/347"
  "[\\x{100}]"
  (backslash "\\u0100")
  '(:unicode t :single-line nil)
  (list (backslash "\\u0100")) )

;;;; testinput4/348: 
;;;
;;;    Matched
;
(test-case
  "pcre-4/348"
  "[\\x{100}]"
  (backslash "Z\\u0100")
  '(:unicode t :single-line nil)
  (list (backslash "\\u0100")) )

;;;; testinput4/349: 
;;;
;;;    Matched
;
(test-case
  "pcre-4/349"
  "[\\x{100}]"
  (backslash "\\u0100Z")
  '(:unicode t :single-line nil)
  (list (backslash "\\u0100")) )

;;;; testinput4/350: 
;;;
;;;    Not matched
;
(test-case
  "pcre-4/350"
  "[\\x{100}]"
  "*** Failers"
  '(:unicode t :single-line nil)
  nil
 )

;;;; testinput4/353: 
;;;
;;;    Matched
;
(test-case
  "pcre-4/353"
  "[Z\\x{100}]"
  (backslash "Z\\u0100")
  '(:unicode t :single-line nil)
  (list "Z") )

;;;; testinput4/354: 
;;;
;;;    Matched
;
(test-case
  "pcre-4/354"
  "[Z\\x{100}]"
  (backslash "\\u0100")
  '(:unicode t :single-line nil)
  (list (backslash "\\u0100")) )

;;;; testinput4/355: 
;;;
;;;    Matched
;
(test-case
  "pcre-4/355"
  "[Z\\x{100}]"
  (backslash "\\u0100Z")
  '(:unicode t :single-line nil)
  (list (backslash "\\u0100")) )

;;;; testinput4/356: 
;;;
;;;    Not matched
;
(test-case
  "pcre-4/356"
  "[Z\\x{100}]"
  "*** Failers"
  '(:unicode t :single-line nil)
  nil
 )

;;;; testinput4/359: 
;;;
;;;    Matched
;
(test-case
  "pcre-4/359"
  "[\\x{100}\\x{200}]"
  (backslash "ab\\u0100cd")
  '(:unicode t :single-line nil)
  (list (backslash "\\u0100")) )

;;;; testinput4/360: 
;;;
;;;    Matched
;
(test-case
  "pcre-4/360"
  "[\\x{100}\\x{200}]"
  (backslash "ab\\u0200cd")
  '(:unicode t :single-line nil)
  (list (backslash "\\u0200")) )

;;;; testinput4/361: 
;;;
;;;    Not matched
;
(test-case
  "pcre-4/361"
  "[\\x{100}\\x{200}]"
  "*** Failers"
  '(:unicode t :single-line nil)
  nil
 )

;;;; testinput4/364: 
;;;
;;;    Matched
;
(test-case
  "pcre-4/364"
  "[\\x{100}-\\x{200}]"
  (backslash "ab\\u0100cd")
  '(:unicode t :single-line nil)
  (list (backslash "\\u0100")) )

;;;; testinput4/365: 
;;;
;;;    Matched
;
(test-case
  "pcre-4/365"
  "[\\x{100}-\\x{200}]"
  (backslash "ab\\u0200cd")
  '(:unicode t :single-line nil)
  (list (backslash "\\u0200")) )

;;;; testinput4/366: 
;;;
;;;    Matched
;
(test-case
  "pcre-4/366"
  "[\\x{100}-\\x{200}]"
  (backslash "ab\\u0111cd")
  '(:unicode t :single-line nil)
  (list (backslash "\\u0111")) )

;;;; testinput4/367: 
;;;
;;;    Not matched
;
(test-case
  "pcre-4/367"
  "[\\x{100}-\\x{200}]"
  "*** Failers"
  '(:unicode t :single-line nil)
  nil
 )

;;;; testinput4/370: 
;;;
;;;    Matched
;
(test-case
  "pcre-4/370"
  "[z-\\x{200}]"
  (backslash "ab\\u0100cd")
  '(:unicode t :single-line nil)
  (list (backslash "\\u0100")) )

;;;; testinput4/371: 
;;;
;;;    Matched
;
(test-case
  "pcre-4/371"
  "[z-\\x{200}]"
  (backslash "ab\\u0200cd")
  '(:unicode t :single-line nil)
  (list (backslash "\\u0200")) )

;;;; testinput4/372: 
;;;
;;;    Matched
;
(test-case
  "pcre-4/372"
  "[z-\\x{200}]"
  (backslash "ab\\u0111cd")
  '(:unicode t :single-line nil)
  (list (backslash "\\u0111")) )

;;;; testinput4/373: 
;;;
;;;    Matched
;
(test-case
  "pcre-4/373"
  "[z-\\x{200}]"
  "abzcd"
  '(:unicode t :single-line nil)
  (list "z") )

;;;; testinput4/374: 
;;;
;;;    Matched
;
(test-case
  "pcre-4/374"
  "[z-\\x{200}]"
  "ab|cd"
  '(:unicode t :single-line nil)
  (list "|") )

;;;; testinput4/375: 
;;;
;;;    Not matched
;
(test-case
  "pcre-4/375"
  "[z-\\x{200}]"
  "*** Failers"
  '(:unicode t :single-line nil)
  nil
 )

;;;; testinput4/378: 
;;;
;;;    Matched
;
(test-case
  "pcre-4/378"
  "[Q\\x{100}\\x{200}]"
  (backslash "ab\\u0100cd")
  '(:unicode t :single-line nil)
  (list (backslash "\\u0100")) )

;;;; testinput4/379: 
;;;
;;;    Matched
;
(test-case
  "pcre-4/379"
  "[Q\\x{100}\\x{200}]"
  (backslash "ab\\u0200cd")
  '(:unicode t :single-line nil)
  (list (backslash "\\u0200")) )

;;;; testinput4/380: 
;;;
;;;    Matched
;
(test-case
  "pcre-4/380"
  "[Q\\x{100}\\x{200}]"
  "Q?"
  '(:unicode t :single-line nil)
  (list "Q") )

;;;; testinput4/381: 
;;;
;;;    Not matched
;
(test-case
  "pcre-4/381"
  "[Q\\x{100}\\x{200}]"
  "*** Failers"
  '(:unicode t :single-line nil)
  nil
 )

;;;; testinput4/384: 
;;;
;;;    Matched
;
(test-case
  "pcre-4/384"
  "[Q\\x{100}-\\x{200}]"
  (backslash "ab\\u0100cd")
  '(:unicode t :single-line nil)
  (list (backslash "\\u0100")) )

;;;; testinput4/385: 
;;;
;;;    Matched
;
(test-case
  "pcre-4/385"
  "[Q\\x{100}-\\x{200}]"
  (backslash "ab\\u0200cd")
  '(:unicode t :single-line nil)
  (list (backslash "\\u0200")) )

;;;; testinput4/386: 
;;;
;;;    Matched
;
(test-case
  "pcre-4/386"
  "[Q\\x{100}-\\x{200}]"
  (backslash "ab\\u0111cd")
  '(:unicode t :single-line nil)
  (list (backslash "\\u0111")) )

;;;; testinput4/387: 
;;;
;;;    Matched
;
(test-case
  "pcre-4/387"
  "[Q\\x{100}-\\x{200}]"
  "Q?"
  '(:unicode t :single-line nil)
  (list "Q") )

;;;; testinput4/388: 
;;;
;;;    Not matched
;
(test-case
  "pcre-4/388"
  "[Q\\x{100}-\\x{200}]"
  "*** Failers"
  '(:unicode t :single-line nil)
  nil
 )

;;;; testinput4/391: 
;;;
;;;    Matched
;
(test-case
  "pcre-4/391"
  "[Qz-\\x{200}]"
  (backslash "ab\\u0100cd")
  '(:unicode t :single-line nil)
  (list (backslash "\\u0100")) )

;;;; testinput4/392: 
;;;
;;;    Matched
;
(test-case
  "pcre-4/392"
  "[Qz-\\x{200}]"
  (backslash "ab\\u0200cd")
  '(:unicode t :single-line nil)
  (list (backslash "\\u0200")) )

;;;; testinput4/393: 
;;;
;;;    Matched
;
(test-case
  "pcre-4/393"
  "[Qz-\\x{200}]"
  (backslash "ab\\u0111cd")
  '(:unicode t :single-line nil)
  (list (backslash "\\u0111")) )

;;;; testinput4/394: 
;;;
;;;    Matched
;
(test-case
  "pcre-4/394"
  "[Qz-\\x{200}]"
  "abzcd"
  '(:unicode t :single-line nil)
  (list "z") )

;;;; testinput4/395: 
;;;
;;;    Matched
;
(test-case
  "pcre-4/395"
  "[Qz-\\x{200}]"
  "ab|cd"
  '(:unicode t :single-line nil)
  (list "|") )

;;;; testinput4/396: 
;;;
;;;    Matched
;
(test-case
  "pcre-4/396"
  "[Qz-\\x{200}]"
  "Q?"
  '(:unicode t :single-line nil)
  (list "Q") )

;;;; testinput4/397: 
;;;
;;;    Not matched
;
(test-case
  "pcre-4/397"
  "[Qz-\\x{200}]"
  "*** Failers"
  '(:unicode t :single-line nil)
  nil
 )

;;;; testinput4/400: 
;;;
;;;    Matched
;
(test-case
  "pcre-4/400"
  "[\\x{100}\\x{200}]{1,3}"
  (backslash "ab\\u0100cd")
  '(:unicode t :single-line nil)
  (list (backslash "\\u0100")) )

;;;; testinput4/401: 
;;;
;;;    Matched
;
(test-case
  "pcre-4/401"
  "[\\x{100}\\x{200}]{1,3}"
  (backslash "ab\\u0200cd")
  '(:unicode t :single-line nil)
  (list (backslash "\\u0200")) )

;;;; testinput4/402: 
;;;
;;;    Matched
;
(test-case
  "pcre-4/402"
  "[\\x{100}\\x{200}]{1,3}"
  (backslash "ab\\u0200\\u0100\\u0200\\u0100cd")
  '(:unicode t :single-line nil)
  (list (backslash "\\u0200\\u0100\\u0200")) )

;;;; testinput4/403: 
;;;
;;;    Not matched
;
(test-case
  "pcre-4/403"
  "[\\x{100}\\x{200}]{1,3}"
  "*** Failers"
  '(:unicode t :single-line nil)
  nil
 )

;;;; testinput4/406: 
;;;
;;;    Matched
;
(test-case
  "pcre-4/406"
  "[\\x{100}\\x{200}]{1,3}?"
  (backslash "ab\\u0100cd")
  '(:unicode t :single-line nil)
  (list (backslash "\\u0100")) )

;;;; testinput4/407: 
;;;
;;;    Matched
;
(test-case
  "pcre-4/407"
  "[\\x{100}\\x{200}]{1,3}?"
  (backslash "ab\\u0200cd")
  '(:unicode t :single-line nil)
  (list (backslash "\\u0200")) )

;;;; testinput4/408: 
;;;
;;;    Matched
;
(test-case
  "pcre-4/408"
  "[\\x{100}\\x{200}]{1,3}?"
  (backslash "ab\\u0200\\u0100\\u0200\\u0100cd")
  '(:unicode t :single-line nil)
  (list (backslash "\\u0200")) )

;;;; testinput4/409: 
;;;
;;;    Not matched
;
(test-case
  "pcre-4/409"
  "[\\x{100}\\x{200}]{1,3}?"
  "*** Failers"
  '(:unicode t :single-line nil)
  nil
 )

;;;; testinput4/412: 
;;;
;;;    Matched
;
(test-case
  "pcre-4/412"
  "[Q\\x{100}\\x{200}]{1,3}"
  (backslash "ab\\u0100cd")
  '(:unicode t :single-line nil)
  (list (backslash "\\u0100")) )

;;;; testinput4/413: 
;;;
;;;    Matched
;
(test-case
  "pcre-4/413"
  "[Q\\x{100}\\x{200}]{1,3}"
  (backslash "ab\\u0200cd")
  '(:unicode t :single-line nil)
  (list (backslash "\\u0200")) )

;;;; testinput4/414: 
;;;
;;;    Matched
;
(test-case
  "pcre-4/414"
  "[Q\\x{100}\\x{200}]{1,3}"
  (backslash "ab\\u0200\\u0100\\u0200\\u0100cd")
  '(:unicode t :single-line nil)
  (list (backslash "\\u0200\\u0100\\u0200")) )

;;;; testinput4/415: 
;;;
;;;    Not matched
;
(test-case
  "pcre-4/415"
  "[Q\\x{100}\\x{200}]{1,3}"
  "*** Failers"
  '(:unicode t :single-line nil)
  nil
 )

;;;; testinput4/418: 
;;;
;;;    Matched
;
(test-case
  "pcre-4/418"
  "[Q\\x{100}\\x{200}]{1,3}?"
  (backslash "ab\\u0100cd")
  '(:unicode t :single-line nil)
  (list (backslash "\\u0100")) )

;;;; testinput4/419: 
;;;
;;;    Matched
;
(test-case
  "pcre-4/419"
  "[Q\\x{100}\\x{200}]{1,3}?"
  (backslash "ab\\u0200cd")
  '(:unicode t :single-line nil)
  (list (backslash "\\u0200")) )

;;;; testinput4/420: 
;;;
;;;    Matched
;
(test-case
  "pcre-4/420"
  "[Q\\x{100}\\x{200}]{1,3}?"
  (backslash "ab\\u0200\\u0100\\u0200\\u0100cd")
  '(:unicode t :single-line nil)
  (list (backslash "\\u0200")) )

;;;; testinput4/421: 
;;;
;;;    Not matched
;
(test-case
  "pcre-4/421"
  "[Q\\x{100}\\x{200}]{1,3}?"
  "*** Failers"
  '(:unicode t :single-line nil)
  nil
 )

;;;; testinput4/424: 
;;;
;;;    Matched
;
(test-case
  "pcre-4/424"
  "(?<=[\\x{100}\\x{200}])X"
  (backslash "abc\\u0200X")
  '(:unicode t :single-line nil)
  (list "X") )

;;;; testinput4/425: 
;;;
;;;    Matched
;
(test-case
  "pcre-4/425"
  "(?<=[\\x{100}\\x{200}])X"
  (backslash "abc\\u0100X")
  '(:unicode t :single-line nil)
  (list "X") )

;;;; testinput4/426: 
;;;
;;;    Not matched
;
(test-case
  "pcre-4/426"
  "(?<=[\\x{100}\\x{200}])X"
  "*** Failers"
  '(:unicode t :single-line nil)
  nil
 )

;;;; testinput4/427: 
;;;
;;;    Not matched
;
(test-case
  "pcre-4/427"
  "(?<=[\\x{100}\\x{200}])X"
  "X"
  '(:unicode t :single-line nil)
  nil
 )

;;;; testinput4/430: 
;;;
;;;    Matched
;
(test-case
  "pcre-4/430"
  "(?<=[Q\\x{100}\\x{200}])X"
  (backslash "abc\\u0200X")
  '(:unicode t :single-line nil)
  (list "X") )

;;;; testinput4/431: 
;;;
;;;    Matched
;
(test-case
  "pcre-4/431"
  "(?<=[Q\\x{100}\\x{200}])X"
  (backslash "abc\\u0100X")
  '(:unicode t :single-line nil)
  (list "X") )

;;;; testinput4/432: 
;;;
;;;    Matched
;
(test-case
  "pcre-4/432"
  "(?<=[Q\\x{100}\\x{200}])X"
  "abQX"
  '(:unicode t :single-line nil)
  (list "X") )

;;;; testinput4/433: 
;;;
;;;    Not matched
;
(test-case
  "pcre-4/433"
  "(?<=[Q\\x{100}\\x{200}])X"
  "*** Failers"
  '(:unicode t :single-line nil)
  nil
 )

;;;; testinput4/434: 
;;;
;;;    Not matched
;
(test-case
  "pcre-4/434"
  "(?<=[Q\\x{100}\\x{200}])X"
  "X"
  '(:unicode t :single-line nil)
  nil
 )

;;;; testinput4/437: 
;;;
;;;    Matched
;
(test-case
  "pcre-4/437"
  "(?<=[\\x{100}\\x{200}]{3})X"
  (backslash "abc\\u0100\\u0200\\u0100X")
  '(:unicode t :single-line nil)
  (list "X") )

;;;; testinput4/438: 
;;;
;;;    Not matched
;
(test-case
  "pcre-4/438"
  "(?<=[\\x{100}\\x{200}]{3})X"
  "*** Failers"
  '(:unicode t :single-line nil)
  nil
 )

;;;; testinput4/439: 
;;;
;;;    Not matched
;
(test-case
  "pcre-4/439"
  "(?<=[\\x{100}\\x{200}]{3})X"
  (backslash "abc\\u0200X")
  '(:unicode t :single-line nil)
  nil
 )

;;;; testinput4/440: 
;;;
;;;    Not matched
;
(test-case
  "pcre-4/440"
  "(?<=[\\x{100}\\x{200}]{3})X"
  "X"
  '(:unicode t :single-line nil)
  nil
 )

;;;; testinput4/443: 
;;;
;;;    Matched
;
(test-case
  "pcre-4/443"
  "[^\\x{100}\\x{200}]X"
  "AX"
  '(:unicode t :single-line nil)
  (list "AX") )

;;;; testinput4/444: 
;;;
;;;    Matched
;
(test-case
  "pcre-4/444"
  "[^\\x{100}\\x{200}]X"
  (backslash "\\u0150X")
  '(:unicode t :single-line nil)
  (list (backslash "\\u0150X")) )

;;;; testinput4/445: 
;;;
;;;    Matched
;
(test-case
  "pcre-4/445"
  "[^\\x{100}\\x{200}]X"
  (backslash "\\u0500X")
  '(:unicode t :single-line nil)
  (list (backslash "\\u0500X")) )

;;;; testinput4/446: 
;;;
;;;    Not matched
;
(test-case
  "pcre-4/446"
  "[^\\x{100}\\x{200}]X"
  "*** Failers"
  '(:unicode t :single-line nil)
  nil
 )

;;;; testinput4/447: 
;;;
;;;    Not matched
;
(test-case
  "pcre-4/447"
  "[^\\x{100}\\x{200}]X"
  (backslash "\\u0100X")
  '(:unicode t :single-line nil)
  nil
 )

;;;; testinput4/448: 
;;;
;;;    Not matched
;
(test-case
  "pcre-4/448"
  "[^\\x{100}\\x{200}]X"
  (backslash "\\u0200X")
  '(:unicode t :single-line nil)
  nil
 )

;;;; testinput4/451: 
;;;
;;;    Matched
;
(test-case
  "pcre-4/451"
  "[^Q\\x{100}\\x{200}]X"
  "AX"
  '(:unicode t :single-line nil)
  (list "AX") )

;;;; testinput4/452: 
;;;
;;;    Matched
;
(test-case
  "pcre-4/452"
  "[^Q\\x{100}\\x{200}]X"
  (backslash "\\u0150X")
  '(:unicode t :single-line nil)
  (list (backslash "\\u0150X")) )

;;;; testinput4/453: 
;;;
;;;    Matched
;
(test-case
  "pcre-4/453"
  "[^Q\\x{100}\\x{200}]X"
  (backslash "\\u0500X")
  '(:unicode t :single-line nil)
  (list (backslash "\\u0500X")) )

;;;; testinput4/454: 
;;;
;;;    Not matched
;
(test-case
  "pcre-4/454"
  "[^Q\\x{100}\\x{200}]X"
  "*** Failers"
  '(:unicode t :single-line nil)
  nil
 )

;;;; testinput4/455: 
;;;
;;;    Not matched
;
(test-case
  "pcre-4/455"
  "[^Q\\x{100}\\x{200}]X"
  (backslash "\\u0100X")
  '(:unicode t :single-line nil)
  nil
 )

;;;; testinput4/456: 
;;;
;;;    Not matched
;
(test-case
  "pcre-4/456"
  "[^Q\\x{100}\\x{200}]X"
  (backslash "\\u0200X")
  '(:unicode t :single-line nil)
  nil
 )

;;;; testinput4/457: 
;;;
;;;    Not matched
;
(test-case
  "pcre-4/457"
  "[^Q\\x{100}\\x{200}]X"
  "QX"
  '(:unicode t :single-line nil)
  nil
 )

;;;; testinput4/460: 
;;;
;;;    Matched
;
(test-case
  "pcre-4/460"
  "[^\\x{100}-\\x{200}]X"
  "AX"
  '(:unicode t :single-line nil)
  (list "AX") )

;;;; testinput4/461: 
;;;
;;;    Matched
;
(test-case
  "pcre-4/461"
  "[^\\x{100}-\\x{200}]X"
  (backslash "\\u0500X")
  '(:unicode t :single-line nil)
  (list (backslash "\\u0500X")) )

;;;; testinput4/462: 
;;;
;;;    Not matched
;
(test-case
  "pcre-4/462"
  "[^\\x{100}-\\x{200}]X"
  "*** Failers"
  '(:unicode t :single-line nil)
  nil
 )

;;;; testinput4/463: 
;;;
;;;    Not matched
;
(test-case
  "pcre-4/463"
  "[^\\x{100}-\\x{200}]X"
  (backslash "\\u0100X")
  '(:unicode t :single-line nil)
  nil
 )

;;;; testinput4/464: 
;;;
;;;    Not matched
;
(test-case
  "pcre-4/464"
  "[^\\x{100}-\\x{200}]X"
  (backslash "\\u0150X")
  '(:unicode t :single-line nil)
  nil
 )

;;;; testinput4/465: 
;;;
;;;    Not matched
;
(test-case
  "pcre-4/465"
  "[^\\x{100}-\\x{200}]X"
  (backslash "\\u0200X")
  '(:unicode t :single-line nil)
  nil
 )

;;;; testinput4/468: 
;;;
;;;    Matched
;
(test-case
  "pcre-4/468"
  "a\\Cb"
  "aXb"
  '(:single-line nil)
  (list "aXb") )

;;;; testinput4/469: 
;;;
;;;    Matched
;
(test-case
  "pcre-4/469"
  "a\\Cb"
  (backslash "a\\nb")
  '(:single-line nil)
  (list (backslash "a\\nb")) )

;;;; testinput4/472: 
;;;
;;;    Matched
;
(test-case
  "pcre-4/472"
  "a\\Cb"
  "aXb"
  '(:unicode t :single-line nil)
  (list "aXb") )

;;;; testinput4/473: 
;;;
;;;    Matched
;
(test-case
  "pcre-4/473"
  "a\\Cb"
  (backslash "a\\nb")
  '(:unicode t :single-line nil)
  (list (backslash "a\\nb")) )

;;;; testinput4/474: 
;;;
;;;    Not matched
;
(test-case
  "pcre-4/474"
  "a\\Cb"
  "*** Failers"
  '(:unicode t :single-line nil)
  nil
 )

;;;; testinput4/475: 
;;;
;;;    Not matched
;
(test-case
  "pcre-4/475"
  "a\\Cb"
  (backslash "a\\u0100b")
  '(:unicode t :single-line nil)
  nil
 )

;;;; testinput4/478: 
;;;
;;;    Matched
;
(test-case
  "pcre-4/478"
  "[z-\\x{100}]"
  "z"
  '(:unicode t :ignore-case t :single-line nil)
  (list "z") )

;;;; testinput4/479: 
;;;
;;;    Matched
;
(test-case
  "pcre-4/479"
  "[z-\\x{100}]"
  "Z"
  '(:unicode t :ignore-case t :single-line nil)
  (list "Z") )

;;;; testinput4/480: 
;;;
;;;    Matched
;
(test-case
  "pcre-4/480"
  "[z-\\x{100}]"
  (backslash "\\u0100")
  '(:unicode t :ignore-case t :single-line nil)
  (list (backslash "\\u0100")) )

;;;; testinput4/481: 
;;;
;;;    Not matched
;
(test-case
  "pcre-4/481"
  "[z-\\x{100}]"
  "*** Failers"
  '(:unicode t :ignore-case t :single-line nil)
  nil
 )

;;;; testinput4/482: 
;;;
;;;    Not matched
;
(test-case
  "pcre-4/482"
  "[z-\\x{100}]"
  (backslash "\\u0101")
  '(:unicode t :ignore-case t :single-line nil)
  nil
 )

;;;; testinput4/483: 
;;;
;;;    Not matched
;
(test-case
  "pcre-4/483"
  "[z-\\x{100}]"
  "y"
  '(:unicode t :ignore-case t :single-line nil)
  nil
 )

;;;; testinput4/486: 
;;;
;;;    Matched
;
(test-case
  "pcre-4/486"
  "[\\xFF]"
  (backslash ">\\u00FF<")
  '(:single-line nil)
  (list (backslash "\\u00FF")) )

;;;; testinput4/489: 
;;;
;;;    Matched
;
(test-case
  "pcre-4/489"
  "[\\xff]"
  (backslash ">\\u00FF<")
  '(:unicode t :single-line nil)
  (list (backslash "\\u00FF")) )

;;;; testinput4/492: 
;;;
;;;    Matched
;
(test-case
  "pcre-4/492"
  "[^\\xFF]"
  "XYZ"
  '(:single-line nil)
  (list "X") )

;;;; testinput4/495: 
;;;
;;;    Matched
;
(test-case
  "pcre-4/495"
  "[^\\xff]"
  "XYZ"
  '(:unicode t :single-line nil)
  (list "X") )

;;;; testinput4/496: 
;;;
;;;    Matched
;
(test-case
  "pcre-4/496"
  "[^\\xff]"
  (backslash "\\u0123")
  '(:unicode t :single-line nil)
  (list (backslash "\\u0123")) )

;;;; testinput4/499: 
;;;
;;;    Not matched
;
(test-case
  "pcre-4/499"
  "^[ac]*b"
  "xb"
  '(:unicode t :single-line nil)
  nil
 )

;;;; testinput4/502: 
;;;
;;;    Not matched
;
(test-case
  "pcre-4/502"
  "^[ac\\x{100}]*b"
  "xb"
  '(:unicode t :single-line nil)
  nil
 )

;;;; testinput4/505: 
;;;
;;;    Not matched
;
(test-case
  "pcre-4/505"
  "^[^x]*b"
  "xb"
  '(:unicode t :ignore-case t :single-line nil)
  nil
 )

;;;; testinput4/508: 
;;;
;;;    Not matched
;
(test-case
  "pcre-4/508"
  "^[^x]*b"
  "xb"
  '(:unicode t :single-line nil)
  nil
 )

;;;; testinput4/511: 
;;;
;;;    Not matched
;
(test-case
  "pcre-4/511"
  "^\\d*b"
  "xb"
  '(:unicode t :single-line nil)
  nil
 )

; EOF
